#pragma once

#include <iostream>
#include "sock.hpp"

namespace select_ns
{
    static const int defaultport = 8081;
    static const int fdnum = sizeof(fd_set) * 8;
    static const int defaultfd = -1;
    class selectServer
    {
    public:
        selectServer(int port = defaultport) : _port(port), _listensock(-1)
        {
        }
        void Print()
        {
            std::cout << "fd list: ";
            for (int i = 0; i < fdnum; i++)
            {
                if (fdarray[i] != defaultfd)
                    std::cout << fdarray[i] << " ";
            }
            std::cout << std::endl;
        }
        void HandlerEvent(fd_set &rfds)
        {
            // 这里目前一定是listensocket，只有这一个
            if (__FD_ISSET(_listensock, &rfds))
            {
                // 走到这里accept函数会不会阻塞？？？  不会
                // select 告诉我，listensocket读事件就绪了
                std::string clienip;
                uint16_t clientport = 0;
                int sock = Sock::Accept(_listensock, &clienip, &clientport);
                if (sock < 0)
                    return;
                logMessage(NORMAL, "accept sucess [%s : %d]", clienip.c_str(), clientport);

                // TODO, 我们能直接recv/read 吗？不能，整个代码，只有select有资格检测事件是否就绪
                // 将新的sock 托管给select!
                // 将新的sock给select的本质，其实就是将sock，添加到fdarray即可
                int i = 0;
                for (i = 0; i < fdnum; i++) // 这里把获取的套接字放到文件描述符的数组
                {
                    if (fdarray[i] != defaultfd)
                        continue;
                    else
                        break;
                }
                if (i == fdnum)
                {
                    logMessage(WARNING, "server if full, please wait");
                    close(sock);
                }
                else
                {
                    fdarray[i] = sock;
                }
                Print();
            }
        }
        void initServer()
        {
            _listensock = Sock::Socket();
            Sock::Bind(_listensock, _port);
            Sock::Listen(_listensock);
            fdarray = new int[fdnum];
            for (int i = 0; i < fdnum; i++)
                fdarray[i] = defaultfd;
            fdarray[0] = _listensock;
        }
        void start()
        {
            /*// 为什么不用这种写法，因为这种写法是阻塞式写法，因为accpet在获取链接时是阻塞式等待，
            // 而listensocket的链接就绪事件就是读事件，所以可以使用select多路转接
            // for (;;)
            // {
            //     std::string clientip;
            //     uint16_t clientport;
            //     int sock = Sock::Accept(_listensock, &clientip, &clientport); // accpet = 等 + 获取 ，所以这里是阻塞式写法
            //     if (sock < 0)
            //         continue;
            // }*/

            // 这个思路就是 accept的时候，我们让select去等，accept只负责获取链接而不会阻塞了
            fd_set rfds;
            FD_ZERO(&rfds);
            FD_SET(_listensock, &rfds); // 把listensocket添加到读文件描述符集中
            int maxfd = fdarray[0];
            for (;;)
            {
                struct timeval timeout
                {
                    1, 0
                };
                for (int i = 0; i < fdnum; i++)
                {
                    if (fdarray[i] == defaultfd)
                        continue;
                    FD_SET(fdarray[i], &rfds); // 合法的fd全部添加到文件描述符集中

                    if (maxfd < fdarray[i])
                    {
                        maxfd = fdarray[i]; // 更新所有fd中最大的fd
                        std::cout << fdarray[i] << std::endl;
                    }
                }
                // int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout); //
                // 一般而言，要是用select，需要程序员自己维护一个保存所有合法fd的数组！
                int n = select(_listensock + 1, &rfds, nullptr, nullptr, nullptr); // 阻塞式等待
                switch (n)
                {
                case 0:
                    logMessage(NORMAL, "timeout...");
                    break;
                case -1:
                    logMessage(WARNING, "select error,code:%d, err string: %s", errno, strerror);
                    break;
                default:
                    // 说明有时间就绪了,目前只有一个监听事件就绪了
                    logMessage(NORMAL, "get a new link...");
                    // 获取链接了
                    HandlerEvent(rfds);
                    break;
                }
                // sleep(1);
            }
        }
        ~selectServer()
        {
            if (_listensock < 0)
                close(_listensock);
        }

    private:
        int _port;
        int _listensock;
        int *fdarray;
    };
} // namespace select_ns